﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SQLite;
using System.IO;
using GS1.Utilitario;
using System.Data;
using log4net;
using System.Configuration;
using SegIdenPC.Entidad;
using SegIdenPC.Herramientas;

namespace SegIdenPC.Helper
{
    /// <summary>
    /// <para>Clase       : SqLiteData</para>
    /// <para>Descripcion : Permite controlar una base de datos en SQLite</para>
    /// <para>Autor       : Pedro Miguel Vera Rafael</para>
    /// <para>Fecha       : 15/06/2011</para>
    /// <para>Empresa     : GS1 Peru</para>
    /// <summary>
    public class SqLiteDataHelper : IDisposable
    {
        #region --- Variable Privadas y Constantes ---
        private static readonly ILog log = LogManager.GetLogger(typeof(SqLiteDataHelper));

        private string CADENACONEXION = string.Empty;
        private SQLiteConnection conexion = null;
        private SQLiteCommand comando = null;
        private StreamReader sr = null;
        private string separador = ",";

        private const string FORMATO_CADENA_CONEXION = "Data Source={0};New={1};Compress=False;Version={2}";
        private const string FORMATO_ERROR_SCRIPT = "Error:{0} \r\n Script: {1} \r\n ¿Desea Continuar?";

        private const string CONFIG_TRANSF_LIMPIAR = "Limpiar";
        private const string CONFIG_SELECCINADO = "Seleccionado = '{0}'";

        private const string COMANDO_SQL_LIMPIAR = "DELETE FROM {0}";
        private const string COMANDO_NOMBRE_TABLA = "NombreTabla";
        #endregion

        #region --- Constantes Entidades ---
        #region --- Constantes Parametros ---
        private const string CODIGO = "CODIGO";
        private const string DESCRIPCION = "DESCRIPCION";
        private const string VALOR = "VALOR";
        #endregion

        #region --- Constantes Tiendas ---
        private const string CODTIENDA = "CODTIENDA";
        private const string NOMBRE = "NOMBRE";
        #endregion

        #region --- Constantes Usuario ---
        private const string CODUSUARIO = "CODUSUARIO";
        private const string NOMBRES = "NOMBRES";
        private const string APELLIDOS = "APELLIDOS";
        private const string NOMUSER = "NOMUSER";
        private const string PASSUSER = "PASSUSER";
        private const string CODROL = "CODROL";
        #endregion

        #region --- Constantes Moneda ---
        private const string CODMONEDA = "CODMONEDA";
        private const string MONEDA = "MONEDA";
        private const string SIMBOLO = "SIMBOLO";
        #endregion

        #region --- Constantes TipoDocumentoVenta ---
        private const string CODTIPODOCUMENTOVENTA = "CODTIPODOCUMENTOVENTA";
        #endregion

        #region --- Constantes FormaVenta ---
        private const string CODFORMAVENTA = "CODFORMAVENTA";
        #endregion

        #region --- Constantes Cliente ---
        private const string CODCLIENTE = "CODCLIENTE";
        private const string RAZONSOCIAL = "RAZONSOCIAL";
        private const string RUC = "RUC";
        private const string DIRECCION = "DIRECCION";
        private const string DISTRITO = "DISTRITO";
        private const string TIPODOCUMENTO = "TIPODOCUMENTO";
        private const string NRODOCUMENTO = "NRODOCUMENTO";
        private const string CODREGION = "CODREGION";
        private const string CODPROVINCIA = "CODPROVINCIA";
        private const string CODDISTRITO = "CODDISTRITO";
        #endregion

        #region --- Constantes Producto ---
        private const string CODPRODUCTO = "CODPRODUCTO";
        private const string PRECIOVENTAMINIMO = "PRECIOVENTAMINIMO";
        private const string PRECIOVENTAMAXIMO = "PRECIOVENTAMAXIMO";
        private const string ALTO = "ALTO";
        private const string ANCHO = "ANCHO";
        private const string LARGO = "LARGO";
        private const string UNIDADMEDIDA = "UNIDADMEDIDA";
        private const string CODNIVELPROD = "CODNIVELPROD";
        private const string CODNIVELTIPO = "CODNIVELTIPO";
        private const string CODNIVELMATERIAL = "CODNIVELMATERIAL";
        private const string CODNIVELCOLOR = "CODNIVELCOLOR";
        private const string CODPROVEEDOR = "CODPROVEEDOR";
        private const string CODPRODUCTOPROVEEDOR = "CODPRODUCTOPROVEEDOR";
        private const string COMPONENTES = "COMPONENTES";
        private const string OBSERVACIONES = "OBSERVACIONES";
        private const string CONSIGNACION = "CONSIGNACION";
        private const string UNIONPRODUCTO = "UNIONPRODUCTO";
        #endregion

        #region --- Constantes Item ---
        private const string CODITEM = "CODITEM";
        private const string CODIFICACION = "CODIFICACION";
        private const string ORIGEN = "ORIGEN";
        private const string PROPIEDADES = "PROPIEDADES";
        private const string PRECIOCOMPRA = "PRECIOCOMPRA";
        private const string CODOC = "CODOC";
        private const string NROLINEA = "NROLINEA";
        private const string PRECIOVENTA = "PRECIOVENTA";
        #endregion

        #region --- Constantes ItemComponente ---
        private const string CODCOMPONENTE = "CODCOMPONENTE";
        private const string CODITEMUNION = "CODITEMUNION";
        private const string UNIONITEM = "UNIONITEM";
        #endregion

        #region --- Constantes Ventas ---
        private const string CODVENTA = "CODVENTA";
        private const string SERIE = "SERIE";
        private const string NUMERO = "NUMERO";
        private const string TOTAL = "TOTAL";
        private const string SUBTOTAL = "SUBTOTAL";
        private const string IGV = "IGV";
        private const string CODDISENIADOR = "CODDISENIADOR";
        private const string SERIENCREDITO = "SERIENCREDITO";
        private const string NUMERONCREDITO = "NUMERONCREDITO";
        private const string DESCUENTO = "DESCUENTO";
        private const string ESTADO = "ESTADO";
        private const string FECHAREGISTRO = "FECHAREGISTRO";
        #endregion

        #region --- Constantes Venta Lineas ---
        private const string PRECIO = "PRECIO";
        private const string CANTIDAD = "CANTIDAD";
        #endregion

        #region --- Constantes Venta Lineas Items ---
        #endregion

        #region --- Constantes Prestamos ---
        private const string CODPRESTAMO = "CODPRESTAMO";
        private const string PERIODOXDIAS = "PERIODOXDIAS";
        private const string FECHAINICIO = "FECHAINICIO";
        private const string FECHAFIN = "FECHAFIN";
        #endregion
        #endregion

        #region --- Constructor y Destructor ---
        public SqLiteDataHelper(string pCadenaConexion)
        {
            CADENACONEXION = pCadenaConexion;
            conexion = new SQLiteConnection(string.Format(FORMATO_CADENA_CONEXION, CADENACONEXION, false, 3));
        }

        public void Dispose()
        {
            if (this.conexion != null) { this.conexion.Dispose(); }
            this.conexion = null;
        }
        #endregion

        #region --- Metodos Iniciales ---
        /// <summary>
        /// Metodo: Que permite crear la BD si no existe en SQLite, apartir del Script
        /// </summary>
        /// <param name="Conexion">Conexion activa</param>
        public void crearBaseDatos()
        {
            string rutaArchivoScript = string.Empty;
            rutaArchivoScript = Libreria.AddSlash(Libreria.RutaApp) + ConfigurationManager.AppSettings[Constantes.ARCHIVO_PC_SCRIPT];

            this.conexion = new SQLiteConnection(string.Format(FORMATO_CADENA_CONEXION, CADENACONEXION, true, 3));
            this.conexion.Open();

            if (ejecutarScript(this.conexion, rutaArchivoScript) == 0) throw new Exception("No se encontró la ruta del script de la base de datos");

            this.conexion.Close();
            this.conexion.ConnectionString = string.Format(FORMATO_CADENA_CONEXION, CADENACONEXION, false, 3);
        }

        /// <summary>
        /// Metodo: que permite crear la BD apartir de archivo Script
        /// </summary>
        /// <param name="Conexion">Conexion activa</param>
        /// <param name="Archivo">Ruta de archivo Script</param>
        /// <returns>Total de tablas creadas</returns>
        private int ejecutarScript(SQLiteConnection Conexion, string Archivo)
        {
            StreamReader sr = null;
            string linea = string.Empty;
            string commandText = string.Empty;
            int totalProcesados = 0;
            SQLiteCommand ocomm = new SQLiteCommand();

            if (!File.Exists(Archivo)) { return 0; }

            try
            {
                sr = new StreamReader(Archivo, Encoding.Default);
            }
            catch (Exception e)
            {
                Libreria.ShowMessageboxError(e.Message, "ExecuteScript");
                return 0;
            }

            linea = sr.ReadLine();
            while (linea != null)
            {
                try
                {
                    if (linea.Length > 0)
                    {
                        if ((linea.Length > 1) &&
                             (linea.Substring(0, 2).ToUpper().Equals("GO")))
                        {
                            totalProcesados++;
                            ocomm.CommandText = commandText;
                            ocomm.Connection = Conexion;
                            ocomm.ExecuteNonQuery();
                            commandText = string.Empty;
                        }
                        else
                        {
                            commandText += linea;
                        }
                    }

                    linea = sr.ReadLine();
                }
                catch (SQLiteException e)
                {
                    if (!Libreria.ShowMessageboxPregunta(string.Format(FORMATO_ERROR_SCRIPT, e.Message,
                                                                                             commandText),
                                                         "ExecuteScript"))
                    {
                        break;
                    }

                    linea = sr.ReadLine();
                    commandText = string.Empty;
                }
                catch (Exception e)
                {
                    if (!Libreria.ShowMessageboxPregunta(string.Format(FORMATO_ERROR_SCRIPT, e.Message,
                                                                                             commandText),
                                                         "ExecuteScript"))
                    {
                        break;
                    }

                    linea = sr.ReadLine();
                    commandText = string.Empty;
                }
            }

            sr.Close();
            sr.Dispose();
            sr = null;

            return totalProcesados;
        }

        /// <summary>
        /// Metodo: Que permite aperturar la conexion a la Base de Datos
        /// </summary>
        /// <returns></returns>
        private SQLiteConnection conectarBD()
        {
            if (conexion.State == ConnectionState.Closed) conexion.Open();
            return conexion;
        }
        #endregion

        #region --- Metodos Genericos ---
        public DataSet exportar()
        {
            DataSet dsExportar = new DataSet();
            DataTable dtTabla = new DataTable();
            SQLiteDataAdapter da = null;

            try
            {
                da = new SQLiteDataAdapter(string.Empty, conexion);
                dtTabla = Constantes.DETALLE_TRANSFERENCIA.Tables["Bajar"];

                foreach (DataRow Fila in dtTabla.Select("Seleccionado = 1"))
                {
                    da.SelectCommand.CommandText = Fila["SentenciaSQL"].ToString();
                    da.Fill(dsExportar, Fila["NombreTabla"].ToString());
                }
            }
            finally
            {
                da.Dispose();
            }

            return dsExportar;
        }

        public int limpiarTablas()
        {
            int resultado = 0;
            DataTable dtTabla = null;

            try
            {
                this.comando = new SQLiteCommand();
                this.comando.Connection = conectarBD();

                this.comando.Transaction = this.conexion.BeginTransaction();

                dtTabla = Constantes.DETALLE_TRANSFERENCIA.Tables[CONFIG_TRANSF_LIMPIAR];
                foreach (DataRow Fila in dtTabla.Select(string.Format(CONFIG_SELECCINADO, Constantes.SI)))
                {
                    this.comando.CommandText = string.Format(COMANDO_SQL_LIMPIAR, Fila[COMANDO_NOMBRE_TABLA]);
                    this.comando.ExecuteNonQuery();
                }

                this.comando.Transaction.Commit();

                resultado = 1;
            }
            finally
            {
                this.comando.Dispose();
                this.comando = null;
            }

            return resultado;
        }

        public void importarCMD(DataTable pTabla, DataRow pFila)
        {
            StringBuilder sentenciaSQL = null;
            int i = 0;
            string temporal = string.Empty;
            string[] listaCampos;
            string[] listaTipos;
            string[] listaLongitudes;
            int n = 0;

            try
            {
                comando = new SQLiteCommand();
                comando.Connection = conexion; conexion.Open();
                comando.Transaction = conexion.BeginTransaction();

                listaTipos = pFila["Tipo"].ToString().Split(separador.ToCharArray());
                listaCampos = pFila["Campos"].ToString().Split(separador.ToCharArray());
                listaLongitudes = pFila["Longitud"].ToString().Split(separador.ToCharArray());

                //--------------------------------------------------------
                comando.CommandText = "DELETE FROM " + pFila["NombreTabla"];
                comando.ExecuteNonQuery();
                //--------------------------------------------------------

                sentenciaSQL = new StringBuilder(); i = 0;
                sentenciaSQL.Append("INSERT INTO " + pFila["NombreTabla"]);
                sentenciaSQL.Append("(" + pFila["Campos"] + ") VALUES(");

                foreach (string campo in listaCampos)
                {
                    temporal = "?";
                    if (i < (listaCampos.Length - 1)) temporal += ",";
                    i += 1;
                    sentenciaSQL.Append(temporal);
                }
                sentenciaSQL.Append(")");

                comando.CommandText = sentenciaSQL.ToString();
                comando.CommandType = CommandType.Text;

                foreach (DataRow fila in pTabla.Rows)
                {
                    n += 1;
                    i = 0;
                    foreach (object valor in fila.ItemArray)
                    {
                        switch (listaTipos[i])
                        {
                            case "S":
                                comando.Parameters[i].Value = Libreria.Mid(valor.ToString().Trim(), 1, listaLongitudes[i].ToEntero());
                                comando.Parameters[i].DbType = DbType.String;
                                break;
                            case "I":
                                comando.Parameters[i].Value = Libreria.Mid(valor.ToString().Trim(), 1, listaLongitudes[i].ToEntero());
                                comando.Parameters[i].DbType = DbType.Int32;
                                break;
                        }
                        i += 1;
                    }

                    try
                    {
                        comando.ExecuteNonQuery();
                    }
                    catch (Exception ex)
                    {
                        log.Error("Error SQLite: Tabla=" + pFila["NombreTabla"] + 
                                  " Reg=" + n.ToString() + " " + 
                                  ex.Message, ex);
                    }

                }

                comando.Transaction.Commit();
                conexion.Close();
            }
            catch (SQLiteException ex)
            {
                comando.Transaction.Rollback();
                conexion.Close();
                throw new Exception("SQLITE: " + ex.Message);
            }
            catch (Exception ex)
            {
                conexion.Close();
                throw new Exception("Común: Tabla=" + pFila["NombreTabla"] + " Reg=" + n.ToString() + " " + ex.Message + "");
            }
            finally
            {
                comando.Dispose();
            }
        }

        public void importarCMD(string pRutaArchivo, DataRow pFila)
        {
            StringBuilder sentenciaSQL;
            string linea, temporal =string.Empty;
            string[] valoresFila;

            string[] listaCampos;
            string[] listaLongitudes;
            string[] listaTipos;

            int i = 0;
            long n = 0;
            string sepCol = separador;

            try
            {
                comando = new SQLiteCommand();
                comando.Connection = conexion; conexion.Open();
                comando.Transaction = conexion.BeginTransaction();

                listaTipos = pFila["Tipo"].ToString().Split(separador.ToCharArray());
                listaCampos = pFila["Campos"].ToString().Split(separador.ToCharArray());
                listaLongitudes = pFila["Longitud"].ToString().Split(separador.ToCharArray());

                //--------------------------------------------------------
                comando.CommandText = "DELETE FROM " + pFila["NombreTabla"];
                comando.ExecuteNonQuery();
                //--------------------------------------------------------

                sr = new StreamReader(File.OpenRead(pRutaArchivo), Encoding.Default);
                linea = sr.ReadLine();

                sentenciaSQL = new StringBuilder(); i = 0;
                sentenciaSQL.Append("INSERT INTO " + pFila["NombreTabla"]);
                sentenciaSQL.Append("(" + pFila["Campos"] + ") VALUES(");

                foreach (string campo in listaCampos)
                {
                    temporal = "?";
                    if (i < (listaCampos.Length - 1)) temporal += ",";
                    i += 1;
                    sentenciaSQL.Append(temporal);
                }
                sentenciaSQL.Append(")");

                comando.CommandText = sentenciaSQL.ToString();
                comando.CommandType = CommandType.Text;

                while (linea != null)
                {
                    n += 1;
                    if (linea.Trim().Length > 0)
                    {
                        if (sepCol != " ")
                        {   //Delimitados por caracter
                            //---------------------------------------------------------------
                            valoresFila = linea.Split(sepCol.ToCharArray());
                            i = 0;
                            foreach (string valor in valoresFila)
                            {
                                switch (listaTipos[i])
                                {
                                    case "S":
                                        comando.Parameters[i].Value = Libreria.Mid(valor.ToString().Trim(), 1, listaLongitudes[i].ToEntero());
                                        comando.Parameters[i].DbType = DbType.String;
                                        break;
                                    case "I":
                                        comando.Parameters[i].Value = Libreria.Mid(valor.ToString().Trim(), 1, listaLongitudes[i].ToEntero());
                                        comando.Parameters[i].DbType = DbType.Int32;
                                        break;
                                }
                                i += 1;
                            }
                        }
                        else
                        {
                            i = 0;
                            int iposi = 1;
                            valoresFila = new string[listaLongitudes.Length - 1];

                            foreach (string iLongi in listaLongitudes)
                            {
                                valoresFila[i] = Libreria.Mid(linea, iposi, iLongi.ToEntero());
                                iposi += Convert.ToInt32(iLongi);
                                i += 1;
                            }

                            i = 0;
                            foreach (string valor in valoresFila)
                            {
                                switch (listaTipos[i])
                                {
                                    case "S":
                                        comando.Parameters[i].Value = valor.ToString().Trim();
                                        comando.Parameters[i].DbType = DbType.String;
                                        break;
                                    case "I":
                                        comando.Parameters[i].Value = valor.ToString().Trim();
                                        comando.Parameters[i].DbType = DbType.Int32;
                                        break;
                                }
                                i += 1;
                            }

                        }
                        //---------------------------------------------------------------

                        comando.Prepare();

                        try
                        {
                            comando.ExecuteNonQuery();
                        }
                        catch (Exception ex)
                        {
                            log.Error("Error SQLite: Tabla=" + pFila["NombreTabla"] + 
                                      " Reg=" + n.ToString() + " " 
                                      + ex.Message , ex);
                        }
                    }
                    linea = sr.ReadLine();
                }
                sr.Close();

                comando.Transaction.Commit(); conexion.Close();
            }
            catch (IOException ex)
            {
                conexion.Close();
                throw new Exception("IO: " + ex.Message);
            }
            catch (SQLiteException ex)
            {
                comando.Transaction.Rollback(); conexion.Close();
                throw new Exception("SQLITE: " + ex.Message);
            }
            catch (Exception ex)
            {
                conexion.Close();
                throw new Exception("Común: Tabla=" + pFila["NombreTabla"] + " Reg=" + n.ToString() + " " + ex.Message);
            }
            finally
            {
                comando.Dispose(); sr.Close();
            }
        }
        #endregion

        #region --- Metodos Propios ---
        public bool importarData(CargaTransferir transferenciaCarga)
        {
            int resultado = 0;
            StringBuilder sentenciaParametroSQL = null;
            StringBuilder sentenciaTiendaSQL = null;
            StringBuilder sentenciaUsuarioSQL = null;
            StringBuilder sentenciaMonedaSQL = null;
            StringBuilder sentenciaTipoDocumentoVentaSQL = null;
            StringBuilder sentenciaFormaVentaSQL = null;
            StringBuilder sentenciaClienteSQL = null;
            StringBuilder sentenciaProductoSQL = null;
            StringBuilder sentenciaItemSQL = null;
            StringBuilder sentenciaItemComponenteSQL = null;

            sentenciaParametroSQL = new StringBuilder();
            sentenciaParametroSQL.Append("INSERT INTO parametro (");
            sentenciaParametroSQL.Append("CODIGO, DESCRIPCION, VALOR) ");
            sentenciaParametroSQL.Append("VALUES (?, ?, ?)");

            sentenciaTiendaSQL = new StringBuilder();
            sentenciaTiendaSQL.Append("INSERT INTO tienda (");
            sentenciaTiendaSQL.Append("CODTIENDA, NOMBRE) ");
            sentenciaTiendaSQL.Append("VALUES(?, ?)");

            sentenciaUsuarioSQL = new StringBuilder();
            sentenciaUsuarioSQL.Append("INSERT INTO usuario ( ");
            sentenciaUsuarioSQL.Append("CODUSUARIO, NOMBRES, APELLIDOS, NOMUSER, PASSUSER, CODROL) ");
            sentenciaUsuarioSQL.Append("VALUES(?, ?, ?, ?, ?, ?)");

            sentenciaMonedaSQL = new StringBuilder();
            sentenciaMonedaSQL.Append("INSERT INTO moneda ( ");
            sentenciaMonedaSQL.Append("CODMONEDA, MONEDA, SIMBOLO) ");
            sentenciaMonedaSQL.Append("VALUES(?, ?, ?)");

            sentenciaTipoDocumentoVentaSQL = new StringBuilder();
            sentenciaTipoDocumentoVentaSQL.Append("INSERT INTO tipo_documento_venta ( ");
            sentenciaTipoDocumentoVentaSQL.Append("CODTIPODOCUMENTOVENTA, DESCRIPCION) ");
            sentenciaTipoDocumentoVentaSQL.Append("VALUES(?, ?)");

            sentenciaFormaVentaSQL = new StringBuilder();
            sentenciaFormaVentaSQL.Append("INSERT INTO forma_venta ( ");
            sentenciaFormaVentaSQL.Append("CODFORMAVENTA, DESCRIPCION) ");
            sentenciaFormaVentaSQL.Append("VALUES(?, ?)");

            sentenciaClienteSQL = new StringBuilder();
            sentenciaClienteSQL.Append("INSERT INTO cliente ( ");
            sentenciaClienteSQL.Append("CODCLIENTE, RAZONSOCIAL, RUC, DIRECCION, DISTRITO, TIPODOCUMENTO, NRODOCUMENTO, CODREGION, CODPROVINCIA, CODDISTRITO) ");
            sentenciaClienteSQL.Append("VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");

            sentenciaProductoSQL = new StringBuilder();
            sentenciaProductoSQL.Append("INSERT INTO producto ( ");
            sentenciaProductoSQL.Append("CODPRODUCTO, DESCRIPCION, PRECIOVENTAMINIMO, PRECIOVENTAMAXIMO, ALTO, ANCHO, LARGO, UNIDADMEDIDA, CODNIVELPROD, CODNIVELTIPO, ");
            sentenciaProductoSQL.Append("CODNIVELMATERIAL, CODNIVELCOLOR, CODPROVEEDOR, CODPRODUCTOPROVEEDOR, COMPONENTES, OBSERVACIONES, CONSIGNACION, UNIONPRODUCTO) ");
            sentenciaProductoSQL.Append("VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");

            sentenciaItemSQL = new StringBuilder();
            sentenciaItemSQL.Append("INSERT INTO item ( ");
            sentenciaItemSQL.Append("CODITEM, CODPRODUCTO, CODIFICACION, CODPROVEEDOR, ORIGEN, PROPIEDADES, PRECIOCOMPRA, CODOC, NROLINEA, CODTIENDA, ");
            sentenciaItemSQL.Append("CODMONEDA, PRECIOVENTA, ESTADO) ");
            sentenciaItemSQL.Append("VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");

            sentenciaItemComponenteSQL = new StringBuilder();
            sentenciaItemComponenteSQL.Append("INSERT INTO item_componente ( ");
            sentenciaItemComponenteSQL.Append("CODITEM, CODCOMPONENTE, CODIFICACION, CODITEMUNION, UNIONITEM) ");
            sentenciaItemComponenteSQL.Append("VALUES(?, ?, ?, ?, ?)");

            try
            {
                using (SQLiteTransaction transa = conectarBD().BeginTransaction())
                {
                    using (this.comando = new SQLiteCommand())
                    {
                        this.comando.Connection = this.conexion;
                        this.comando.Transaction = transa;
                        this.comando.CommandType = CommandType.Text;

                        #region --- Grabar Parametro ---
                        this.comando.CommandText = sentenciaParametroSQL.ToString();
                        this.comando.Parameters.Clear();

                        this.comando.Parameters.Add(CODIGO, DbType.Int32);
                        this.comando.Parameters.Add(DESCRIPCION, DbType.String);
                        this.comando.Parameters.Add(VALOR, DbType.String);

                        this.comando.Prepare();

                        foreach (Parametro parametro in transferenciaCarga.listaParametro.lista)
                        {
                            this.comando.Parameters[CODIGO].Value = parametro.codigo;
                            this.comando.Parameters[DESCRIPCION].Value = parametro.descripcion;
                            this.comando.Parameters[VALOR].Value = parametro.valor;

                            resultado += this.comando.ExecuteNonQuery();
                        }
                        #endregion

                        #region --- Grabar Tienda ---
                        this.comando.CommandText = sentenciaTiendaSQL.ToString();
                        this.comando.Parameters.Add(CODTIENDA, DbType.Int32);
                        this.comando.Parameters.Add(NOMBRE, DbType.String);
                        this.comando.Prepare();

                        this.comando.Parameters[CODTIENDA].Value = ParametrosAplicacion.TIENDA_ACTUAL.codigo;
                        this.comando.Parameters[NOMBRE].Value = ParametrosAplicacion.TIENDA_ACTUAL.nombre;

                        resultado += this.comando.ExecuteNonQuery();
                        #endregion

                        #region --- Grabar Usuario ---
                        this.comando.CommandText = sentenciaUsuarioSQL.ToString();
                        this.comando.Parameters.Clear();

                        this.comando.Parameters.Add(CODUSUARIO, DbType.Int32);
                        this.comando.Parameters.Add(NOMBRES, DbType.String);
                        this.comando.Parameters.Add(APELLIDOS, DbType.String);
                        this.comando.Parameters.Add(NOMUSER, DbType.String);
                        this.comando.Parameters.Add(PASSUSER, DbType.String);
                        this.comando.Parameters.Add(CODROL, DbType.Int32);

                        this.comando.Prepare();

                        foreach (Usuario usuario in transferenciaCarga.listaUsuario.lista)
                        {
                            this.comando.Parameters[CODUSUARIO].Value = usuario.codUsuario;
                            this.comando.Parameters[NOMBRES].Value = usuario.nombres;
                            this.comando.Parameters[APELLIDOS].Value = usuario.apellidos;
                            this.comando.Parameters[NOMUSER].Value = usuario.nomUser;
                            this.comando.Parameters[PASSUSER].Value = usuario.passUser;
                            this.comando.Parameters[CODROL].Value = usuario.rol.codigo;

                            resultado += this.comando.ExecuteNonQuery();
                        }
                        #endregion

                        #region --- Grabar Moneda ---
                        this.comando.CommandText = sentenciaMonedaSQL.ToString();
                        this.comando.Parameters.Clear();

                        this.comando.Parameters.Add(CODMONEDA, DbType.Int32);
                        this.comando.Parameters.Add(MONEDA, DbType.String);
                        this.comando.Parameters.Add(SIMBOLO, DbType.String);
                        this.comando.Prepare();

                        foreach (Moneda moneda in transferenciaCarga.listaMoneda.lista)
                        {
                            this.comando.Parameters[CODMONEDA].Value = moneda.codigo;
                            this.comando.Parameters[MONEDA].Value = moneda.descripcion;
                            this.comando.Parameters[SIMBOLO].Value = moneda.simbolo;

                            resultado += this.comando.ExecuteNonQuery();
                        }
                        #endregion

                        #region --- Grabar Tipo Documento Venta ---
                        this.comando.CommandText = sentenciaTipoDocumentoVentaSQL.ToString();
                        this.comando.Parameters.Clear();

                        this.comando.Parameters.Add(CODTIPODOCUMENTOVENTA, DbType.Int32);
                        this.comando.Parameters.Add(DESCRIPCION, DbType.String);
                        this.comando.Prepare();

                        foreach (TipoDocumentoVenta tipoDocumentoVenta in transferenciaCarga.listaTipoDocumentoVenta.lista)
                        {
                            this.comando.Parameters[CODTIPODOCUMENTOVENTA].Value = tipoDocumentoVenta.codigo;
                            this.comando.Parameters[DESCRIPCION].Value = tipoDocumentoVenta.descripcion;

                            resultado += this.comando.ExecuteNonQuery();
                        }
                        #endregion

                        #region --- Grabar Forma Venta ---
                        this.comando.CommandText = sentenciaFormaVentaSQL.ToString();
                        this.comando.Parameters.Clear();

                        this.comando.Parameters.Add(CODFORMAVENTA, DbType.String);
                        this.comando.Parameters.Add(DESCRIPCION, DbType.String);
                        this.comando.Prepare();

                        foreach (FormaVenta formaVenta in transferenciaCarga.listaFormaVenta.lista)
                        {
                            this.comando.Parameters[CODFORMAVENTA].Value = formaVenta.codigo;
                            this.comando.Parameters[DESCRIPCION].Value = formaVenta.descripcion;

                            resultado += this.comando.ExecuteNonQuery();
                        }
                        #endregion

                        #region --- Grabar Cliente ---
                        this.comando.CommandText = sentenciaClienteSQL.ToString();
                        this.comando.Parameters.Clear();

                        this.comando.Parameters.Add(CODCLIENTE, DbType.String);
                        this.comando.Parameters.Add(RAZONSOCIAL, DbType.String);
                        this.comando.Parameters.Add(RUC, DbType.String);
                        this.comando.Parameters.Add(DIRECCION, DbType.String);
                        this.comando.Parameters.Add(DISTRITO, DbType.String);
                        this.comando.Parameters.Add(TIPODOCUMENTO, DbType.String);
                        this.comando.Parameters.Add(NRODOCUMENTO, DbType.String);
                        this.comando.Parameters.Add(CODREGION, DbType.String);
                        this.comando.Parameters.Add(CODPROVINCIA, DbType.String);
                        this.comando.Parameters.Add(CODDISTRITO, DbType.String);

                        foreach (Cliente cliente in transferenciaCarga.listaCliente.lista)
                        {
                            this.comando.Parameters[CODCLIENTE].Value = cliente.codCliente;
                            this.comando.Parameters[RAZONSOCIAL].Value = cliente.razonSocial;
                            this.comando.Parameters[RUC].Value = cliente.ruc;
                            this.comando.Parameters[DIRECCION].Value = cliente.direccion;
                            this.comando.Parameters[DISTRITO].Value = cliente.distrito;
                            this.comando.Parameters[TIPODOCUMENTO].Value = cliente.tipoDocumento;
                            this.comando.Parameters[NRODOCUMENTO].Value = cliente.nroDocumento;
                            this.comando.Parameters[CODREGION].Value = cliente.distrito.codRegion;
                            this.comando.Parameters[CODPROVINCIA].Value = cliente.distrito.codProvincia;
                            this.comando.Parameters[CODDISTRITO].Value = cliente.distrito.codigo;

                            resultado += this.comando.ExecuteNonQuery();
                        }
                        #endregion

                        #region --- Grabar Producto ---
                        this.comando.CommandText = sentenciaProductoSQL.ToString();
                        this.comando.Parameters.Clear();

                        this.comando.Parameters.Add(CODPRODUCTO, DbType.Int32);
                        this.comando.Parameters.Add(DESCRIPCION, DbType.String);
                        this.comando.Parameters.Add(PRECIOVENTAMINIMO, DbType.Decimal);
                        this.comando.Parameters.Add(PRECIOVENTAMAXIMO, DbType.Decimal);
                        this.comando.Parameters.Add(ALTO, DbType.Decimal);
                        this.comando.Parameters.Add(ANCHO, DbType.Decimal);
                        this.comando.Parameters.Add(LARGO, DbType.Decimal);
                        this.comando.Parameters.Add(UNIDADMEDIDA, DbType.String);
                        this.comando.Parameters.Add(CODNIVELPROD, DbType.Int32);
                        this.comando.Parameters.Add(CODNIVELTIPO, DbType.Int32);
                        this.comando.Parameters.Add(CODNIVELMATERIAL, DbType.Int32);
                        this.comando.Parameters.Add(CODNIVELCOLOR, DbType.Int32);
                        this.comando.Parameters.Add(CODPROVEEDOR, DbType.Int32);
                        this.comando.Parameters.Add(CODPRODUCTOPROVEEDOR, DbType.String);
                        this.comando.Parameters.Add(COMPONENTES, DbType.String);
                        this.comando.Parameters.Add(OBSERVACIONES, DbType.String);
                        this.comando.Parameters.Add(CONSIGNACION, DbType.String);
                        this.comando.Parameters.Add(UNIONPRODUCTO, DbType.String);

                        foreach (Producto producto in transferenciaCarga.listaProducto.lista)
                        {
                            this.comando.Parameters[CODPRODUCTO].Value = producto.codigo;
                            this.comando.Parameters[DESCRIPCION].Value = producto.descripcion;
                            this.comando.Parameters[PRECIOVENTAMINIMO].Value = producto.precioVentaMinimo;
                            this.comando.Parameters[PRECIOVENTAMAXIMO].Value = producto.precioVentaMaximo;
                            this.comando.Parameters[ALTO].Value = producto.alto;
                            this.comando.Parameters[ANCHO].Value = producto.ancho;
                            this.comando.Parameters[LARGO].Value = producto.largo;
                            this.comando.Parameters[UNIDADMEDIDA].Value = producto.unidadMedida;
                            this.comando.Parameters[CODNIVELPROD].Value = producto.nivelProducto.codigo;
                            this.comando.Parameters[CODNIVELTIPO].Value = producto.nivelTipo.codigo;
                            this.comando.Parameters[CODNIVELMATERIAL].Value = producto.nivelMaterial.codigo;
                            this.comando.Parameters[CODNIVELCOLOR].Value = producto.nivelColor.codigo;
                            this.comando.Parameters[CODPROVEEDOR].Value = producto.proveedor.codProveedor;
                            this.comando.Parameters[CODPRODUCTOPROVEEDOR].Value = producto.codProductoProveedor;
                            this.comando.Parameters[COMPONENTES].Value = producto.componentes;
                            this.comando.Parameters[OBSERVACIONES].Value = producto.observaciones;
                            this.comando.Parameters[CONSIGNACION].Value = producto.consignacion;
                            this.comando.Parameters[UNIONPRODUCTO].Value = producto.unionProducto;

                            resultado += this.comando.ExecuteNonQuery();
                        }
                        #endregion

                        #region --- Grabar Item ---
                        this.comando.CommandText = sentenciaItemSQL.ToString();
                        this.comando.Parameters.Clear();

                        this.comando.Parameters.Add(CODITEM, DbType.String);
                        this.comando.Parameters.Add(CODPRODUCTO, DbType.String);
                        this.comando.Parameters.Add(CODIFICACION, DbType.String);
                        this.comando.Parameters.Add(CODPROVEEDOR, DbType.String);
                        this.comando.Parameters.Add(ORIGEN, DbType.String);
                        this.comando.Parameters.Add(PROPIEDADES, DbType.String);
                        this.comando.Parameters.Add(PRECIOCOMPRA, DbType.String);
                        this.comando.Parameters.Add(CODOC, DbType.String);
                        this.comando.Parameters.Add(NROLINEA, DbType.String);
                        this.comando.Parameters.Add(CODTIENDA, DbType.String);
                        this.comando.Parameters.Add(CODMONEDA, DbType.String);
                        this.comando.Parameters.Add(PRECIOVENTA, DbType.String);
                        this.comando.Parameters.Add(ESTADO, DbType.String);

                        foreach (Item item in transferenciaCarga.listaItem.lista)
                        {
                            this.comando.Parameters[CODITEM].Value = item.codItem;
                            this.comando.Parameters[CODPRODUCTO].Value = item.producto.codigo;
                            this.comando.Parameters[CODIFICACION].Value = item.codificacion;
                            this.comando.Parameters[CODPROVEEDOR].Value = item.proveedor.codProveedor;
                            this.comando.Parameters[ORIGEN].Value = item.origen;
                            this.comando.Parameters[PROPIEDADES].Value = item.propiedades;
                            this.comando.Parameters[PRECIOCOMPRA].Value = item.precioCompra;
                            this.comando.Parameters[CODOC].Value = item.lineaOrdenCompra.codOC;
                            this.comando.Parameters[NROLINEA].Value = item.lineaOrdenCompra.numeroLinea;
                            this.comando.Parameters[CODTIENDA].Value = item.tienda.codigo;
                            this.comando.Parameters[CODMONEDA].Value = item.moneda.codigo;
                            this.comando.Parameters[PRECIOVENTA].Value = item.precioVenta;
                            this.comando.Parameters[ESTADO].Value = item.estado;

                            resultado += this.comando.ExecuteNonQuery();
                        }
                        #endregion

                        #region --- Grabar Item Componente ---
                        this.comando.CommandText = sentenciaItemComponenteSQL.ToString();
                        this.comando.Parameters.Clear();

                        this.comando.Parameters.Add(CODITEM, DbType.String);
                        this.comando.Parameters.Add(CODCOMPONENTE, DbType.String);
                        this.comando.Parameters.Add(CODIFICACION, DbType.String);
                        this.comando.Parameters.Add(CODITEMUNION, DbType.String);
                        this.comando.Parameters.Add(UNIONITEM, DbType.String);

                        foreach (ItemComponente itemComponente in transferenciaCarga.listaItemComponente.lista)
                        {
                            this.comando.Parameters[CODITEM].Value = itemComponente.codItem;
                            this.comando.Parameters[CODCOMPONENTE].Value = itemComponente.codComponente;
                            this.comando.Parameters[CODIFICACION].Value = itemComponente.codificacion;
                            this.comando.Parameters[CODITEMUNION].Value = itemComponente.item.codItem;
                            this.comando.Parameters[UNIONITEM].Value = itemComponente.unionItem;

                            resultado += this.comando.ExecuteNonQuery();
                        }
                        #endregion
                    }

                    transa.Commit();
                }
            }
            finally
            {
                this.conexion.Close();
            }

            return resultado > 0;
        }

        public DescargaTransferir exportarData()
        {
            DescargaTransferir descargaTransferir = null;

            ListaVenta listaVentaObtenido = null;
            ListaPrestamo listaPrestamoObtenido = null;

            try
            {
                conectarBD();

                descargaTransferir = new DescargaTransferir();

                // Obtener Ventas
                listaVentaObtenido = obtenerVentas();
                foreach (Venta venta in listaVentaObtenido.lista)
                {
                    ListaLineaVenta listaLineaVentaTemporal = obtenerVentaLineas(venta);

                    foreach (LineaVenta lineaVenta in listaLineaVentaTemporal.lista)
                    {
                        lineaVenta.listaLineaVentaItem = obtenerVentaLineasItems(lineaVenta);
                    }

                    venta.listaLineaVenta = listaLineaVentaTemporal;
                }
                descargaTransferir.listaVenta = listaVentaObtenido;

                // Obtener Prestamos
                listaPrestamoObtenido = obtenerPrestamos();
                foreach (Prestamo prestamo in listaPrestamoObtenido.lista)
                {
                    prestamo.listaItem = obtenerPrestamoLineas(prestamo);
                }

                descargaTransferir.listaPrestamos = listaPrestamoObtenido;
            }
            finally
            {
                if (this.conexion != null) { this.conexion.Close(); }
            }

            return descargaTransferir;
        }

        #region --- DAO Ventas ---
        private ListaVenta obtenerVentas()
        {
            ListaVenta listaVentas = null;
            StringBuilder sentenciaSQL = null;

            sentenciaSQL = new StringBuilder();
            sentenciaSQL.Append("SELECT CODVENTA, SERIE, NUMERO, CODCLIENTE, CODTIPODOCUMENTOVENTA, CODMONEDA, CODFORMAVENTA,");
            sentenciaSQL.Append("TOTAL, SUBTOTAL, IGV, CODUSUARIO, CODDISENIADOR, CODTIENDA,");
            sentenciaSQL.Append("SERIENCREDITO, NUMERONCREDITO, DESCUENTO, ESTADO, FECHAREGISTRO ");
            sentenciaSQL.Append("FROM venta ");

            listaVentas = new ListaVenta();
            using (this.comando = new SQLiteCommand())
            {
                this.comando.Connection = this.conexion;
                this.comando.CommandText = sentenciaSQL.ToString();
                this.comando.CommandType = CommandType.Text;

                using (SQLiteDataReader dr = this.comando.ExecuteReader())
                {
                    while (dr.Read())
                    {
                        listaVentas.lista.Add(generarEntidadVenta(dr));
                    }
                }
            }

            return listaVentas;
        }

        private Venta generarEntidadVenta(SQLiteDataReader dr)
        {
            Venta ventaObtenido = null;

            ventaObtenido = new Venta();
            ventaObtenido.codVenta = dr[CODVENTA].ToString();
            ventaObtenido.serie = dr[SERIE].ToString();
            ventaObtenido.numero = dr[NUMERO].ToString();
            
            ventaObtenido.cliente = new Cliente();
            ventaObtenido.cliente.codCliente = dr[CODCLIENTE].ToString();

            ventaObtenido.tipoDocumentoVenta = new TipoDocumentoVenta();
            ventaObtenido.tipoDocumentoVenta.codigo = dr[CODTIPODOCUMENTOVENTA].ToString();

            ventaObtenido.moneda = new Moneda();
            ventaObtenido.moneda.codigo = dr[CODMONEDA].ToString();

            ventaObtenido.formaVenta = new FormaVenta();
            ventaObtenido.formaVenta.codigo = dr[CODFORMAVENTA].ToString();

            ventaObtenido.total = Convert.ToDouble(dr[TOTAL]);
            ventaObtenido.subTotal = Convert.ToDouble(dr[SUBTOTAL]);
            ventaObtenido.igv = Convert.ToDouble(dr[IGV]);
            ventaObtenido.descuento = Convert.ToDouble(dr[DESCUENTO]);

            ventaObtenido.usuario = new Usuario();
            ventaObtenido.usuario.codUsuario = dr[CODUSUARIO].ToString();

            ventaObtenido.diseniador = new Diseniador();
            ventaObtenido.diseniador.codDiseniador = dr[CODDISENIADOR].ToString();

            ventaObtenido.tienda = new Tienda();
            ventaObtenido.tienda.codigo = dr[CODTIENDA].ToString();

            ventaObtenido.notaCreditoNumero = dr[NUMERONCREDITO].ToString();
            ventaObtenido.notaCreditoSerie = dr[SERIENCREDITO].ToString();

            ventaObtenido.estado = dr[ESTADO].ToString();

            ventaObtenido.fechaRegistro = Convert.ToDateTime(dr[FECHAREGISTRO]).ToString(Constantes.FORMATO_FECHAHORA);

            return ventaObtenido;
        }
        #endregion

        #region --- DAO Venta Lineas ---
        private ListaLineaVenta obtenerVentaLineas(Venta venta)
        {
            ListaLineaVenta listaLineasVenta = null;
            StringBuilder sentenciaSQL = null;

            sentenciaSQL = new StringBuilder();
            sentenciaSQL.Append("SELECT NROLINEA, CODVENTA, CODPRODUCTO, PRECIO, CANTIDAD ");
            sentenciaSQL.Append("FROM det_venta ");
            sentenciaSQL.Append("WHERE CODVENTA =" + venta.codVenta);

            listaLineasVenta = new ListaLineaVenta();
            using (this.comando = new SQLiteCommand())
            {
                this.comando.Connection = this.conexion;
                this.comando.CommandText = sentenciaSQL.ToString();
                this.comando.CommandType = CommandType.Text;

                using (SQLiteDataReader dr = this.comando.ExecuteReader())
                {
                    while (dr.Read())
                    {
                        listaLineasVenta.lista.Add(generarEntidadLineaVenta(dr));
                    }
                }
            }

            return listaLineasVenta;
        }

        private LineaVenta generarEntidadLineaVenta(SQLiteDataReader dr)
        {
            LineaVenta lineaVentaObtenido = null;

            lineaVentaObtenido = new LineaVenta();
            lineaVentaObtenido.numeroLinea = dr[NROLINEA].ToString();
            lineaVentaObtenido.codVenta = dr[CODVENTA].ToString();

            lineaVentaObtenido.producto = new Producto();
            lineaVentaObtenido.producto.codigo = dr[CODPRODUCTO].ToString();

            lineaVentaObtenido.precio = Convert.ToDouble(dr[PRECIO]);
            lineaVentaObtenido.cantidad = dr[CANTIDAD].ToString();

            return lineaVentaObtenido;
        }
        #endregion

        #region --- DAO Venta Lineas Item ---
        private ListaLineaVentaItem obtenerVentaLineasItems(LineaVenta lineaVenta)
        {
            ListaLineaVentaItem listaLineasItemsVenta = null;
            StringBuilder sentenciaSQL = null;

            sentenciaSQL = new StringBuilder();
            sentenciaSQL.Append("SELECT NROLINEA,CODVENTA,CODITEM ");
            sentenciaSQL.Append("FROM det_venta_item ");
            sentenciaSQL.Append("WHERE NROLINEA =" + lineaVenta.numeroLinea + " ");
            sentenciaSQL.Append("AND CODVENTA =" + lineaVenta.codVenta);

            listaLineasItemsVenta = new ListaLineaVentaItem();
            using (this.comando = new SQLiteCommand())
            {
                this.comando.Connection = this.conexion;
                this.comando.CommandText = sentenciaSQL.ToString();
                this.comando.CommandType = CommandType.Text;

                using (SQLiteDataReader dr = this.comando.ExecuteReader())
                {
                    while (dr.Read())
                    {
                        listaLineasItemsVenta.lista.Add(generarEntidadLineaItemVenta(dr));
                    }
                }
            }

            return listaLineasItemsVenta;
        }

        private LineaVentaItem generarEntidadLineaItemVenta(SQLiteDataReader dr)
        {
            LineaVentaItem lineaVentaItemObtenido = null;

            lineaVentaItemObtenido = new LineaVentaItem();
            lineaVentaItemObtenido.numeroLinea = dr[NROLINEA].ToString();
            lineaVentaItemObtenido.codVenta = dr[CODVENTA].ToString();

            lineaVentaItemObtenido.item = new Item();
            lineaVentaItemObtenido.item.codItem = dr[CODITEM].ToString();

            return lineaVentaItemObtenido;
        }
        #endregion

        #region --- DAO Prestamos ---
        private ListaPrestamo obtenerPrestamos()
        {
            ListaPrestamo listaPrestamos = null;
            StringBuilder sentenciaSQL = null;

            sentenciaSQL = new StringBuilder();
            sentenciaSQL.Append("SELECT CODPRESTAMO, CODCLIENTE, CODTIENDA, PERIODOXDIAS, FECHAINICIO, FECHAFIN,");
            sentenciaSQL.Append("CODUSUARIO, CODDISENIADOR, ESTADO, FECHAREGISTRO ");
            sentenciaSQL.Append("FROM prestamo ");

            listaPrestamos = new ListaPrestamo();
            using (this.comando = new SQLiteCommand())
            {
                this.comando.Connection = this.conexion;
                this.comando.CommandText = sentenciaSQL.ToString();
                this.comando.CommandType = CommandType.Text;

                using (SQLiteDataReader dr = this.comando.ExecuteReader())
                {
                    while (dr.Read())
                    {
                        listaPrestamos.lista.Add(generarEntidadPrestamo(dr));
                    }
                }
            }

            return listaPrestamos;
        }

        private Prestamo generarEntidadPrestamo(SQLiteDataReader dr)
        {
            Prestamo prestamoObtenido = null;

            prestamoObtenido = new Prestamo();
            prestamoObtenido.codPrestamo = dr[CODDISENIADOR].ToString();

            prestamoObtenido.cliente = new Cliente();
            prestamoObtenido.cliente.codCliente = dr[CODCLIENTE].ToString();

            prestamoObtenido.tienda = new Tienda();
            prestamoObtenido.tienda.codigo = dr[CODTIENDA].ToString();

            prestamoObtenido.periodoxDias = dr[PERIODOXDIAS].ToString();
            prestamoObtenido.fechaInicio = Convert.ToDateTime(dr[FECHAINICIO]).ToString(Constantes.FORMATO_FECHAHORA);
            prestamoObtenido.fechaFin = Convert.ToDateTime(dr[FECHAFIN]).ToString(Constantes.FORMATO_FECHAHORA);

            prestamoObtenido.usuario = new Usuario();
            prestamoObtenido.usuario.codUsuario = dr[CODUSUARIO].ToString();

            prestamoObtenido.diseniador = new Diseniador();
            prestamoObtenido.diseniador.codDiseniador = dr[CODDISENIADOR].ToString();

            prestamoObtenido.estado = dr[ESTADO].ToString();

            prestamoObtenido.fechaRegistro = Convert.ToDateTime(dr[FECHAREGISTRO]).ToString(Constantes.FORMATO_FECHAHORA);

            return prestamoObtenido;
        }
        #endregion

        #region --- DAO Prestamos Lineas/Items ---
        private ListaItem obtenerPrestamoLineas(Prestamo prestamo)
        {
            ListaItem listaItems = null;
            StringBuilder sentenciaSQL = null;

            sentenciaSQL = new StringBuilder();
            sentenciaSQL.Append("SELECT CODPRESTAMO, CODITEM ");
            sentenciaSQL.Append("FROM det_prestamo ");
            sentenciaSQL.Append("WHERE CODPRESTAMO =" + prestamo.codPrestamo);

            listaItems = new ListaItem();
            using (this.comando = new SQLiteCommand())
            {
                this.comando.Connection = this.conexion;
                this.comando.CommandText = sentenciaSQL.ToString();
                this.comando.CommandType = CommandType.Text;

                using (SQLiteDataReader dr = this.comando.ExecuteReader())
                {
                    while (dr.Read())
                    {
                        listaItems.lista.Add(generarEntidadItemPrestamo(dr));
                    }
                }
            }

            return listaItems;
        }

        private Item generarEntidadItemPrestamo(SQLiteDataReader dr)
        {
            Item itemObtenido = null;

            itemObtenido = new Item();
            itemObtenido.codItem = dr[CODITEM].ToString();

            return itemObtenido;
        }
        #endregion
        #endregion
    }
}